home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DApp / SeqPup.cpp < prev    next >
C/C++ Source or Header  |  1996-07-05  |  21KB  |  818 lines
  1. // SeqPup.cp
  2. // d.g.gilbert -- biosequence editor & analysis platform
  3. // Jan 1994
  4.  
  5. #define UseGopher  0
  6. #undef  DEBUG
  7. #define SEQASM
  8.  
  9. #include <DClap.h>
  10. #if UseGopher
  11. #  include <DNet.h>
  12. #else
  13. #  include <DTCP.h>
  14. #  include <DSMTPclient.h>
  15. #  include <DSendMailDialog.h>
  16. #endif
  17. #include <DBio.h>
  18. #include <DRich.h>
  19. #include <DDrawPICT.h>
  20. #include <DSeqPict.h>
  21. #include <Dversion.h>
  22. #include <DBOPclient.h>
  23.  
  24. #ifdef SEQASM
  25. #include <DSeqAsmDoc.h>
  26. #endif
  27.  
  28. #if DEBUG
  29. #include <DebugNew.h>
  30. #endif
  31.  
  32. void AboutSeqPupPicture(); // DAboutSeqPup.cpp
  33.  
  34.  
  35.  
  36. class DSeqPup : public DApplication
  37. {
  38. public:
  39.     static char* kBugmailAddress;
  40.     static char* kGopherRTFDocSuffix;
  41.     
  42.     enum appMenus { kInternetMenu = 100, kPrefsMenu, kOpenMenu };  
  43.     enum menuCmds { 
  44.         kSeqPrefs=1001,  kOtherPrefs, kEditGopherMap,
  45.         kViewByDefault,kViewByDate,kViewBySize,kViewByName,kViewByKind,kViewByHost,
  46.         kViewAsText, kViewAsLink,
  47.         kOpenDoc, kFetchLink, kFetchDefault, // kFetchView1...kFetchViewN
  48.         kFetchOptionFlag, kAutoloadFlag,
  49.         kViewPrefs, kCodonPref,kREnzymePref,kColorPref,kStylePref,
  50.         kSaveWinPrefs,kSeqPrintPrefs, kSeqDocPrefs, kBOPprefs,
  51.         kGetInfo, kMailAdmin, kOpenLocalGo,
  52.         kNewServer,kFindServer,kNewLink, kEditLink,kExtractGodoc,kLockWindow,
  53.         kOpenText, kOpenSeq, kOpenAppendSeq, kOpenTree,  
  54.         kMailSetup, kSendMail, kBugMail
  55.         };
  56.  
  57.     DView *    fFetchOptionMenuItem;
  58.     DView *    fLockWinMenuItem;
  59.     DView * fAutoloadItem;
  60.     DMenu * fViewsMenu;
  61.     Boolean fWinPrefsNotSaved, fAppendSeq;
  62.     
  63.     void ISeqPup();     
  64.     virtual ~DSeqPup();
  65.     void DoAboutBox();
  66.  
  67.     virtual void SetUpMenus();    
  68.     virtual Boolean DoMenuTask(long tasknum, DTask* theTask);
  69.     virtual    Boolean IsMyAction(DTaskMaster* action);
  70.     virtual Boolean IsInternetMenu(DTaskMaster* action); 
  71.     virtual    void UpdateMenus(); 
  72.     virtual void OpenDocument(DFile* aFile);
  73.     virtual void OpenLocalGopher();
  74.     DWindow* DoMakeDocument(short itsCommandNumber, DFile* aFile);
  75. };
  76.  
  77.  
  78. char* DSeqPup::kBugmailAddress= "seqpup@bio.indiana.edu";
  79. char* DSeqPup::kGopherRTFDocSuffix = ".start";
  80.  
  81.  
  82.     // here we go -- the Nlm_Main() program (called from main() in ncbimain.c)
  83. extern "C" short Main(void)
  84. {
  85.   DSeqPup* app = new DSeqPup();
  86.   app->ISeqPup();
  87.   app->Run();
  88.   delete app; 
  89.   return 0;
  90. }
  91.  
  92.  
  93.  
  94. void DSeqPup::ISeqPup()
  95. {
  96.     DApplication::kName= "SeqPup";
  97.     DApplication::kVersion= (char*) kDCLAPVersionString; //" v 0.4";
  98.     
  99.     fFetchOptionMenuItem= NULL;
  100.     fLockWinMenuItem= NULL;
  101.     fWinPrefsNotSaved= true;
  102.     fAppendSeq= false;
  103.     fAutoloadItem = NULL;
  104. #if UseGopher
  105.     gGopherDoc = NULL; // ??? this should be set, but isn't in 68K ??
  106. #endif
  107.     fViewsMenu= NULL;
  108.     fFileSuffix = NULL; // unix, msdos file suffix
  109.     fAcceptableFileTypes = NULL;     // really want "IGo4 BKMK TEXT" and perhaps others
  110.                                                                 // but NCBI tools only handle 1 type now
  111.     IApplication();
  112.     
  113. #if UseGopher
  114.         // network doc initializations
  115.     InitializeUGopher();
  116.     DGoviewPrefs::InitGlobals();
  117.     DGoOtherPrefs::InitGlobals();
  118.     if (fFetchOptionMenuItem) fFetchOptionMenuItem->SetStatus(DGopherListDoc::gOptionIsOn);
  119.     if (fAutoloadItem) fAutoloadItem->SetStatus(DGoLinkedTextDoc::gAutoloadInlines);
  120. #endif
  121.  
  122.     DRichView::InitRichView();
  123.     
  124.         // sequence initializations
  125.     DSeqDoc::GetGlobals(); //SeqDocPrefs(kSeqDocPrefInit);
  126.     DCodons::Initialize("codon","data","tables:codon.table");
  127.     DREMap::Initialize("renzyme","data","tables:renzyme.table");
  128.     DBaseColors::Initialize("color","data","tables:color.table");
  129.     if (DBaseColors::NotAvailable()) ; // read in DBaseColors data now 
  130.     DStyleTable::Initialize("seqmasks","data","tables:seqmasks.table");
  131.     if (DStyleTable::NotAvailable()) ; // read in DStyleTable data now 
  132.     
  133.         // default documents ??
  134.   if (! OpenStartDocs() )
  135.     if (DSeqDoc::fgStartDoc) DSeqDoc::NewSeqDoc();
  136.     
  137.     {
  138.         // open default gopher document if it exists.
  139.         // TRY RTF Form first (.start ?? )
  140.         // open both default.go4 and default.start files, if they exist !
  141.     char godefault[512];
  142. #if UseGopher
  143.     StrNCpy(godefault, (char*)Shortname(), 512);    
  144.     StrNCat(godefault, DGopherListDoc::kGopherDocSuffix, 512);
  145.     DApplication::OpenDocument( (char*)godefault);
  146. #endif
  147.     StrNCpy(godefault, (char*)Shortname(), 512);    
  148.     StrNCat(godefault, kGopherRTFDocSuffix, 512);
  149.     DApplication::OpenDocument( (char*)godefault);
  150.     }
  151.  
  152. }     
  153.  
  154.  
  155. DSeqPup::~DSeqPup()
  156. {
  157. #if UseGopher
  158.     DGoviewPrefs::SaveGlobals();
  159.     DGoOtherPrefs::SaveGlobals();
  160. #endif
  161.     if (fWinPrefsNotSaved) DSeqDoc::SaveGlobals(); 
  162.     DDrawPict::Cleanup();
  163. }
  164.  
  165.  
  166. void DSeqPup::DoAboutBox()
  167. {
  168. #if !defined(WIN_MSWIN) && !defined(WIN_MOTIF)
  169.         // problems yet w/ this large codepic in mswin(WIN16) and unix/motif
  170.     AboutSeqPupPicture();
  171. #else
  172.     char aboutMe[512];
  173.     sprintf( aboutMe, "SeqPup, version %s"LINEEND
  174.                 " a biosequence editor & analysis application "LINEEND
  175.                 " copyright by D.G. Gilbert, 1990-1995"
  176.                 , DApplication::kVersion);
  177.     DAboutBoxWindow* about = new DAboutBoxWindow(aboutMe);
  178. #endif
  179. }
  180.  
  181.  
  182. void DSeqPup::SetUpMenus(void)
  183. {
  184.     //DApplication::SetUpMenus();
  185.  
  186.     DMenu* aMenu = NULL;
  187. #ifdef WIN_MAC
  188.     DAppleMenu* appleMenu = new DAppleMenu(this,fAboutLine);
  189. #endif
  190.     if (!aMenu) aMenu = this->NewMenu( cFileMenu, "File");
  191. #ifndef WIN_MAC
  192.     aMenu->AddItem(kAbout, fAboutLine);
  193.     aMenu->AddSeparator();
  194. #endif
  195.     aMenu->AddItem(kNew,"New/N", false, true);
  196.  
  197.     aMenu->AddItem( kOpenSeq, "Open sequence.../O",false, true);
  198.     //aMenu->AddItem(kOpen,"Open.../O",false, true);
  199.     DMenu* oMenu= new DSubMenu( kOpenMenu, aMenu, "Open other");
  200.     //oMenu->AddItem( kOpenSeq, "Sequence file.../O",false, true);
  201.     oMenu->AddItem( kOpenText, "Text,RTF,Image...",false, true);
  202.     oMenu->AddItem( kOpenAppendSeq, "Append sequence...",false, true);
  203.     //oMenu->AddItem( kOpenTree, "Phylogenetic tree...",false, true);
  204.     //oMenu->AddItem( kOpenLocalGo,"Open Local gopher...",false, true);
  205.     //oMenu->AddItem( kNewServer,"Open Remote.../R",false, true);
  206.  
  207.     aMenu->AddSeparator();
  208.     aMenu->AddItem(kClose,"Close/W",false, true);
  209.     aMenu->AddItem(kSave,"Save/S",false, true);
  210.     aMenu->AddItem(kSaveAs,"Save As...",false, true);
  211.     aMenu->AddItem(DSeqDoc::cSaveSel,"Save selection...",false, true);
  212.     aMenu->AddItem(DSeqDoc::cRevert,"Revert to saved",false, true);
  213.     aMenu->AddSeparator();
  214.     aMenu->AddItem(kPrint,"Print",false, true);
  215.     aMenu->AddItem(kHelp,"Help/H",false, true);
  216.     aMenu->AddSeparator();
  217.     aMenu->AddItem(kQuit,"Quit/Q",false, true);
  218.  
  219.     aMenu= NULL;
  220.     this->SetUpMenu(DApplication::cEditMenu, aMenu);
  221.     DSeqDoc::SetUpMenu(DApplication::cEditMenu, aMenu);
  222.  
  223.     DMenu* sMenu = NULL;
  224.     DSeqDoc::SetUpMenu(DSeqDoc::kSeqMenu, sMenu);
  225.  
  226.     DMenu* iMenu = NewMenu( kInternetMenu, "Internet");
  227.     //iMenu->AddItem( kMailSetup, "Mail setup...");
  228.      //iMenu->AddSeparator();        
  229.  
  230.     DSeqDoc::SetUpMenu(DSeqDoc::kInternetMenu, iMenu);
  231.      iMenu->AddSeparator();        
  232.     DSeqApps::SetUpMenu(DSeqDoc::kInternetMenu, iMenu, "inet");
  233.      iMenu->AddSeparator();        
  234.     iMenu->AddItem( kSendMail, "Send Mail...");
  235.     iMenu->AddItem( kBugMail, "Comment on this app...");
  236.  
  237.     DMenu* cMenu = NULL;
  238.     DSeqApps::SetUpMenu(DSeqApps::kChildMenu, cMenu, DSeqApps::kAppSection);
  239.     
  240.     iMenu = NewMenu( kPrefsMenu, "Options");
  241.     iMenu->AddItem( kSeqDocPrefs, "Seq Prefs...",false, true);
  242.     iMenu->AddItem( kSeqPrintPrefs, "SeqPrint Prefs...", false, true); 
  243.     iMenu->AddItem( kColorPref, "Base color table...", false, true);
  244.     iMenu->AddItem( kStylePref, "Base style table...", false, true);
  245.     iMenu->AddItem( kCodonPref, "Codon table...", false, true);
  246.     iMenu->AddItem( kREnzymePref, "R.Enzyme table...", false, true);
  247.     iMenu->AddItem( kSaveWinPrefs, "Save window settings", false, true);
  248.     // add opt to save current aln window size,text-lock,color-state to prefs ?
  249.     // or do automatically on close?
  250.     iMenu->AddSeparator();
  251.     
  252. #if UseGopher
  253.     iMenu->AddItem( kViewPrefs, "View Prefs...", false, true); 
  254. #if NETSTUF_LATER
  255.     iMenu->AddItem( kFetchOptionFlag, "Fetch with options", true, true);
  256.         // we can only access menu item thru gViewCentral now the way DMenu::AddItem() is written...
  257.     fFetchOptionMenuItem= (DView*) gViewCentral->GetView(kFetchOptionFlag);
  258.  
  259.     iMenu->AddItem( kAutoloadFlag, "Autoload images", true, true);
  260.     fAutoloadItem= (DView*) gViewCentral->GetView(kAutoloadFlag);
  261.     iMenu->AddItem( kEditGopherMap, "Edit view handlers...",false, true);
  262.     iMenu->AddItem( kOtherPrefs,     "Other prefs...",false, true);
  263. #endif
  264. #endif
  265.     iMenu->AddItem( kBOPprefs,  "BOP setup...", false, true);
  266.     iMenu->AddItem( kMailSetup, "Mail setup...",false, true);
  267.  
  268.     aMenu= NULL;
  269.     this->SetUpMenu(DApplication::cWindowMenu, aMenu);
  270.     
  271.     this->SetUpMenu( 0, aMenu);
  272. }
  273.  
  274.  
  275.  
  276.  
  277.  
  278. class    DBugMailDialog : public DSendMailDialog
  279. {
  280. public:
  281.     DBugMailDialog(long id, DTaskMaster* itsSuperior,
  282.         short width = -5, short height = -5, short left = -50, short top = -20, char* title = NULL):
  283.         DSendMailDialog(id, itsSuperior, width, height, left, top, title)
  284.         {}
  285.  
  286.     virtual DView* InstallTo(DView* super, char* toStr)  //override
  287.     {
  288.         return DSendMailDialog::InstallTo(super, DSeqPup::kBugmailAddress);
  289.     }
  290. };
  291.  
  292.  
  293.  
  294. #if UseGopher
  295. class DLocalDialog : public DWindow
  296. {
  297. public:
  298.     enum { kSetDefault = 13345 };
  299.     DEditText* fQuery;
  300.     DLocalDialog();            
  301.     char* Result();
  302.     void OkayAction();
  303. };
  304.  
  305.  
  306. DLocalDialog::DLocalDialog() :
  307.     DWindow( 0, gApplication, fixed, -10, -10, -50, -20, "Local Gopher", kDontFreeOnClose)
  308. {
  309.         new DPrompt(0, this, "Open local folder?", 0, 0, Nlm_systemFont);             
  310.         this->NextSubviewBelowLeft();
  311.         fQuery= new DEditText(0, this, gLocalGopherRoot, 28); 
  312.         this->SetEditText(fQuery);
  313.         this->NextSubviewBelowLeft();
  314.         (void) new DCheckBox(kSetDefault,this,"Make this default local services folder");
  315.         this->AddOkayCancelButtons();
  316. }
  317.             
  318. void DLocalDialog::OkayAction() 
  319. { 
  320.     DWindow::OkayAction();
  321.     DCheckBox* ck = (DCheckBox*) this->FindSubview(kSetDefault);
  322.     if (ck && ck->GetStatus()) {
  323.         char* newroot= fQuery->GetText(); // this dups text
  324.         if (newroot) {
  325.             MemFree(gLocalGopherRoot);
  326.             gLocalGopherRoot= newroot;
  327.             }
  328.         }
  329. }
  330.  
  331. char* DLocalDialog::Result()
  332. {
  333.     if (fOkay) return fQuery->GetText();
  334.     else return NULL;
  335. }
  336. #endif
  337.  
  338.  
  339. void DSeqPup::OpenLocalGopher()
  340. {
  341. #if UseGopher
  342.     DLocalDialog* win= new DLocalDialog();
  343.     if ( win->PoseModally() ) {
  344.         char* localpath= win->Result();
  345.       DGopher* localgo= DGopherList::LocalGopher( localpath);
  346.         MemFree( localpath);
  347.       DGopherListDoc::ProcessGopher( localgo, 0);
  348.       }
  349.     delete win;  
  350. #endif
  351. }
  352.         
  353.  
  354. // DEBUG TEST of DChildDlogDoc
  355. #include "DChildDlogDoc.h"
  356.  
  357. void DSeqPup::OpenDocument(DFile* aFile)
  358. {
  359.     if (!aFile || !aFile->Exists()) return;
  360.     gCursor->watch();
  361.  
  362. #ifdef SEQASM    
  363.     if (DSeqAsmDoc::IsAutoseqFile(aFile)) {
  364.         
  365.         fAppendSeq= true; // !? expect ~6 data files from autoseq analysis
  366.                                             // all belong to same window...
  367.                                             // can we load these at same time somehow ??
  368.                                             // e.g., same file name, diff. suffix?
  369.         if (fAppendSeq) {
  370.             DSeqAsmDoc* sdoc= (DSeqAsmDoc*) gWindowManager->CurrentWindow();
  371.             if (sdoc && sdoc->Id() == DSeqAsmDoc::kSeqAsmdoc) 
  372.                 sdoc->Open(aFile);   
  373.             else
  374.                 fAppendSeq= false;
  375.             }
  376.         if (!fAppendSeq) {
  377.             DSeqAsmDoc* sdoc= new DSeqAsmDoc(DSeqAsmDoc::kSeqAsmdoc, NULL, NULL);
  378.             sdoc->Open(aFile);   
  379.             }
  380.         }
  381.     else 
  382. #endif
  383.  
  384.     if (DSeqDoc::IsSeqFile(aFile)) {
  385.         if (fAppendSeq) {
  386.             DSeqDoc* sdoc= (DSeqDoc*) gWindowManager->CurrentWindow();
  387.             if (sdoc && sdoc->Id() == DSeqDoc::kSeqdoc) 
  388.                 sdoc->Open(aFile);   
  389.             else
  390.                 fAppendSeq= false;
  391.             }
  392.         if (!fAppendSeq) {
  393.             DSeqDoc* sdoc= new DSeqDoc(DSeqDoc::kSeqdoc, NULL, NULL);
  394.             sdoc->Open(aFile);   
  395.             }
  396.         }
  397.         
  398.     else {
  399.         aFile->Close();
  400. #if UseGopher
  401.       DGopher* localgo= DGopherList::LocalGopher( aFile);
  402.       DGopherListDoc::ProcessGopher( localgo, 0);
  403. #else
  404.                 // DEBUG TEST of DChildDlogDoc ...
  405.         //DChildDlogDoc* doc= new DChildDlogDoc( 0, gTextFont);
  406.         DRichTextDoc* doc= new DRichTextDoc( 0, true, gTextFont);
  407.         doc->Open( aFile);
  408. #endif
  409.         }
  410.     gCursor->arrow();
  411. }
  412.  
  413.  
  414.  
  415. DWindow* DSeqPup::DoMakeDocument(short itsCommandNumber, DFile* aFile)
  416. {
  417.     DWindow* theDoc= NULL;
  418.     
  419.      switch (itsCommandNumber) {
  420. #if 0
  421.         case cOpenNAColors:
  422.         case cOpenAAColors: {
  423.             DColorPrefDocument* aDoc= new DColorPrefDocument();
  424.             if (itsCommandNumber == cOpenAAColors)
  425.                 aDoc->IColorPrefDocument( itsFile, kAmino);
  426.             else 
  427.                 aDoc->IColorPrefDocument( itsFile, kDNA);
  428.             return aDoc;
  429.             }
  430.  
  431.         case cOpenTree: {
  432.             DTreeDoc* aDoc= new DTreeDoc();
  433.             aDoc->ITreePrintDocument(kPrintClipType, NULL, NIL, itsFile);
  434.             return aDoc;
  435.             }
  436.         
  437.         // also handle gopher documents ... some gopher method should do this
  438.         
  439.         default:  { //== cNewProj/cOpenProj, cNew/cOpen
  440.             DAlnDoc* aDoc= new DAlnDoc();
  441.             aDoc->IAlnDoc( itsFile);
  442.             return aDoc;
  443.             }
  444. #endif
  445.         }
  446.         
  447.     return theDoc;
  448. }
  449.  
  450.  
  451.  
  452.  
  453.  
  454.         
  455. Boolean DSeqPup::IsInternetMenu(DTaskMaster* action) 
  456. {
  457.     DWindow* win;
  458.     DSeqDoc* sdoc = (DSeqDoc*) gWindowManager->CurrentWindow();
  459.  
  460.     switch(action->Id()) {
  461.  
  462.         case kCodonPref: 
  463.             DCodons::TableChoice();
  464.             return true;
  465.  
  466.         case kColorPref: 
  467.             DBaseColors::TableChoice();
  468.             return true;
  469.  
  470.         case kStylePref: 
  471.             DStyleTable::TableChoice();
  472.             return true;
  473.             
  474.         case kREnzymePref: 
  475.             DREMap::TableChoice();
  476.             return true;
  477.             
  478.         case kSaveWinPrefs: 
  479.             if (sdoc && sdoc->Id() == DSeqDoc::kSeqdoc) {
  480.                 sdoc->MakeGlobalsCurrent();
  481.                 DSeqDoc::SaveGlobals();
  482.                 fWinPrefsNotSaved= false;
  483.                 }
  484.             return true;
  485.  
  486.         case kBOPprefs: 
  487.             BOPSetLogon();
  488.             return true;
  489.  
  490.         case kSeqDocPrefs: 
  491.             SeqDocPrefs(kSeqDocPrefDialog);
  492.             return true;
  493.     
  494.         case kSeqPrintPrefs: 
  495.             SeqPrintPrefs(kSeqPrintPrefDialog);
  496.             return true;
  497.  
  498. #if UseGopher
  499.         case kViewPrefs: 
  500.             if (!gGoviewPrefs) {
  501.                 gGoviewPrefs = new DGoviewPrefs();
  502.                 gGoviewPrefs->Initialize();
  503.                 }
  504.             if (gGoviewPrefs && gGoviewPrefs->PoseModally()) ;
  505.             //delete gGoviewPrefs; // leave the window hidden but alive for later use
  506.             return true;
  507.             
  508.         case kOtherPrefs:
  509.             if (!gGoOtherPrefs) {
  510.                 gGoOtherPrefs = new DGoOtherPrefs();
  511.                 gGoOtherPrefs->Initialize();
  512.                 }
  513.             if (gGoOtherPrefs && gGoOtherPrefs->PoseModally()) ;
  514.             //delete gGoOtherPrefs; // leave the window hidden but alive for later use
  515.             return true;
  516.  
  517.         case  kFetchOptionFlag:
  518.             if (fFetchOptionMenuItem) DGopherListDoc::gOptionIsOn= fFetchOptionMenuItem->GetStatus();
  519.             else DGopherListDoc::gOptionIsOn = !DGopherListDoc::gOptionIsOn; // or read menu state
  520.             return true;
  521.  
  522.         case  kAutoloadFlag:
  523.             if (fAutoloadItem) DGoLinkedTextDoc::gAutoloadInlines= fAutoloadItem->GetStatus();
  524.             else DGoLinkedTextDoc::gAutoloadInlines = !DGoLinkedTextDoc::gAutoloadInlines; // or read menu state
  525.             return true;
  526.  
  527.         case  kExtractGodoc:
  528.             {
  529.             win= gWindowManager->CurrentWindow();
  530.             if (win && win->Id() == DGoLinkedTextDoc::kGoLitextdoc) {
  531.                 DGoLinkedTextDoc* ndoc= (DGoLinkedTextDoc *) win;
  532.                 switch (action->Id()) {
  533.                     case kExtractGodoc    : ndoc->ExtractGopherDoc(); break;
  534.                     }
  535.                 }
  536.             return true;
  537.             }
  538.  
  539.  
  540.         case  kLockWindow:
  541.             win= gWindowManager->CurrentWindow();
  542.             if (win && fLockWinMenuItem) {
  543.                 if (win->Id() == DGopherListDoc::kGoListdoc)
  544.                      ((DGopherListDoc *) win)->PinWindow( fLockWinMenuItem->GetStatus());
  545.                 else if (win->Id() == DGopherTextDoc::kGoTextdoc   
  546.                             || win->Id() == DGoLinkedTextDoc::kGoLitextdoc)  
  547.                     ((DGopherTextDoc *) win)->PinWindow( fLockWinMenuItem->GetStatus());
  548.                 }         
  549.             return true;
  550. #endif
  551.  
  552. #if UseGopher
  553.         case     kGetInfo:
  554.         case  kFetchLink:
  555.         case  kMailAdmin:
  556.         case    kFindServer:
  557.         case    kNewServer:
  558.         case    kNewLink:
  559.         case  kEditLink:
  560.             {
  561.             win= gWindowManager->CurrentWindow();
  562.             if (win && win->Id() == DGopherListDoc::kGoListdoc) {
  563.                 DGopher* go;
  564.                 short iview;
  565.                 DGopherListDoc* gdoc= (DGopherListDoc *) win;
  566.                 switch (action->Id()) {
  567.  
  568.                     case kFindServer:    gdoc->TopOfGopherHole(); break;
  569.                     case kNewServer    : gdoc->InsertNewGopher( false); break;
  570.                     case kNewLink        : gdoc->InsertNewGopher( true); break;
  571.                     case kEditLink    : gdoc->EditOldGopher(); break;
  572.                     case kGetInfo:
  573.                         iview= DGopher::kGetItemInfo;
  574.                             // fall thru to kFetchLink
  575.                     case kFetchLink:
  576.                         go= gdoc->fGoview->SelectedGopher();
  577.                         if (go) gdoc->ProcessGopher(go, iview);
  578.                         break;
  579. #if 0                    
  580.                     case kMailAdmin    :
  581.                         go= gdoc->fGoview->SelectedGopher();
  582.                         if (go && go->fAdminEmail) {
  583.                             win= new DAdminMailDialog(0, this, go);
  584.                             win->Open();
  585.                             }
  586.                         break;
  587. #endif
  588.                     }
  589.                 }
  590.             return true;
  591.             }
  592. #endif
  593.  
  594.          case    kMailSetup:
  595.             {
  596.             win= new DMailSetupDialog(0, this, -10, -10, -20, -20, "Mail Setup");
  597.             win->Open();
  598.             return true;
  599.             }
  600.         case     kSendMail: 
  601.             {
  602.             win= new DSendMailDialog(0, this, -10, -10, -20, -20, "Send Mail");
  603.             win->Open();
  604.             return true;
  605.             }
  606.         case  kBugMail:
  607.             {
  608.             win= new DBugMailDialog(0, this, -10, -10, -20, -20, "Comment about this App");
  609.             win->Open();
  610.             return true;
  611.             }
  612.             
  613.         default:    
  614.             if (sdoc && sdoc->Id() == DSeqDoc::kSeqdoc) 
  615.                 return sdoc->IsMyAction(action);
  616.             else return false;
  617.         }
  618. }
  619.  
  620.  
  621. Boolean DSeqPup::DoMenuTask(long tasknum, DTask* theTask)
  622. {
  623.     switch (tasknum) {
  624.     
  625.         case kPrintAFile:    
  626.         case kOpenAFile:
  627.             DSeqDoc::fgTestSeqFile= true;  
  628.             (void) DApplication::DoMenuTask(tasknum,theTask);
  629.             DSeqDoc::fgTestSeqFile= false;
  630.             return true;
  631.             
  632.         default: 
  633.             return DApplication::DoMenuTask(tasknum, theTask);
  634.         }
  635. }
  636.  
  637.  
  638. Boolean DSeqPup::IsMyAction(DTaskMaster* action) 
  639. {
  640.     enum doctype { nodoc, anydoc, godoc, seq1doc, alndoc };
  641.     static DTaskMaster* curaction = NULL;
  642.     doctype        thedoc = nodoc;
  643.     Boolean        done= true, result= false;
  644.     
  645.     Boolean inrecurse= (curaction == action);  
  646.     if (inrecurse) return false; // prevent infinite loop here...
  647.     curaction= action;
  648.     
  649.     DWindow* win     = gWindowManager->CurrentWindow();
  650.     DSeqDoc* sdoc = (DSeqDoc*) win;
  651.     DSeqedWindow* s1doc= (DSeqedWindow*) win;
  652. #if UseGopher
  653.     DGopherListDoc* gdoc = (DGopherListDoc*) win;
  654. #endif
  655.     if (win) {
  656.         if (win->Id() == DSeqDoc::kSeqdoc) thedoc = alndoc;
  657.         else if (win->Id() == DSeqedWindow::kId) thedoc = seq1doc;
  658. #if UseGopher
  659.         else if (win->Id() == DGopherListDoc::kGoListdoc) thedoc = godoc;
  660. #endif
  661.         else thedoc= anydoc;
  662.         }
  663.         
  664.     short    menuitem = action->Id();
  665.     short menuid= (action->fSuperior) ? action->fSuperior->Id() : 0;
  666.  
  667.     if ((menuid == kInternetMenu
  668.         ||menuid == DSeqApps::kChildMenu)
  669.      && (menuitem >= DSeqApps::kChildMenuBaseID 
  670.          && menuitem <= DSeqApps::kChildMenuBaseID + 50) // +50 = HACK !! need better way to distinguish menu items !
  671.     ) goto caseChildMenu;
  672.         
  673.     if (action->fSuperior)  
  674.         switch (action->fSuperior->Id()) {
  675.                 
  676.             case kOpenMenu : 
  677.             case cFileMenu : 
  678.               switch (menuitem) {
  679.               
  680.                 case kNewServer:
  681.                     result= IsInternetMenu(action);
  682.                     break;
  683.                     
  684.                 case DSeqDoc::cSaveSel:
  685.                 case DSeqDoc::cRevert:
  686.                     goto caseSeqDoc;
  687.                     
  688.                 case DApplication::kNew:
  689. #if DEBUG
  690.                     if ( gKeys->option()) { 
  691.                         DebugNewReportLeaks();
  692.                         }
  693.                     else
  694. #endif
  695.                         DSeqDoc::NewSeqDoc();
  696.                     result= true;
  697.                     break;
  698.                     
  699.                 case kOpenText:
  700.                     DApplication::DoMenuTask(DApplication::kOpen, NULL);
  701.                     result= true;
  702.                     break;
  703.                     
  704.                 case kOpenTree:
  705.                     result= true;
  706.                     break;
  707.  
  708.                 case kOpenAppendSeq:
  709.                     fAppendSeq= true;
  710.                 case kOpenSeq:
  711.                 case DApplication::kOpen:
  712.                     DSeqDoc::fgTestSeqFile= true; // ???
  713.                     DApplication::DoMenuTask(DApplication::kOpen,NULL);
  714.                     DSeqDoc::fgTestSeqFile= false;
  715.                     fAppendSeq= false;
  716.                     result= true;
  717.                     break;
  718.                     
  719. #if UseGopher
  720.                 case kOpenLocalGo:
  721.                     OpenLocalGopher();
  722.                     result= true;
  723.                     break;
  724. #endif
  725.                  default: 
  726.                     result= DApplication::IsMyAction(action);
  727.                     break;
  728.                 }
  729.                 break;
  730.         
  731.             case DApplication::cEditMenu:
  732.                 if (thedoc == alndoc) done= sdoc->IsMyAction(action);
  733.                 else if (thedoc == seq1doc) done= s1doc->IsMyAction(action);
  734.                 else done= false;
  735.                 if (done) result= true;
  736.                 break;
  737.                 
  738.             case kInternetMenu    :
  739.             case kPrefsMenu : 
  740. #if UseGopher
  741.                 if (menuitem == DGopherListDoc::kViewChoiceMenu) 
  742.                     goto caseViewChoiceMenu; 
  743.                 else
  744. #endif
  745.                   result= IsInternetMenu(action);
  746.                 break;
  747.                     
  748. #if UseGopher
  749.             case DGopherListDoc::kViewKindMenu    : 
  750.                 if (thedoc == godoc) result= gdoc->IsMyAction(action);
  751.                 else result= false;
  752.                 beak;
  753.                 
  754.             case DGopherListDoc::kViewChoiceMenu    : 
  755.             caseViewChoiceMenu:
  756.                 if (thedoc == godoc) result= gdoc->IsMyAction(action);
  757.                 else result= false;
  758.                 break;
  759. #endif
  760.             
  761.             case DSeqApps::kChildMenu :
  762.             caseChildMenu:
  763.                 if (thedoc == alndoc) result= sdoc->IsMyAction(action);
  764.                 else if (thedoc == seq1doc) result= s1doc->IsMyAction(action);
  765.                 else {
  766.                     DSeqApps::CallChildApp( menuitem, NULL);
  767.                     result= true;
  768.                     }
  769.                 break;
  770.  
  771.             case DSeqDoc::kSeqMenu    : 
  772.             case DSeqDoc::kViewKindMenu    : 
  773.             case DSeqDoc::kSeqMaskMenu    : 
  774.             caseSeqDoc:
  775.                 switch(menuitem) {
  776.                     case DSeqDoc::cNAcodes: NucCodesPicture(); result= true; break;
  777.                     case DSeqDoc::cAAcodes: AminoCodesPicture(); result= true; break;
  778.                     default:
  779.                         if (thedoc == alndoc) result= sdoc->IsMyAction(action);
  780.                         else if (thedoc == seq1doc) result= s1doc->IsMyAction(action);
  781.                         else result= false;
  782.                         break;
  783.                     }
  784.                 break;
  785.                 
  786.             default:
  787.                 done= false;
  788.                 break;
  789.             }
  790.      
  791.      
  792.     if (!done) switch(menuitem) {
  793.         case DApplication::kNew:
  794.             DSeqDoc::NewSeqDoc();
  795.             result= true;
  796.             break;
  797.         default: 
  798.             result= DApplication::IsMyAction(action);
  799.             break;
  800.         }
  801.          
  802.     inrecurse= false;
  803.     curaction= NULL;
  804.     return result;
  805. }
  806.  
  807.  
  808.  
  809. void DSeqPup::UpdateMenus(void)
  810. {
  811.     DApplication::UpdateMenus();
  812.     
  813.     //gViewCentral->EnableView(kSpecial1);
  814.     //gViewCentral->EnableView(kSpecial2);
  815. }
  816.  
  817.  
  818.